import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

public class day5 {
    /**
     * 过桥
     * https://ac.nowcoder.com/acm/problem/229296
     */
    public static int INF = 0x3f3f3f3f;
    public static int n;
    public static int[] arr = new int[2001];

    public static void main3(String[] args) {
        Scanner in = new Scanner(System.in);
        n = in.nextInt();
        for(int i = 1;i <= n;i++) {
            arr[i] = in.nextInt();
        }
        System.out.println(bfs());
    }
    // 写法二：
    public static int bfs2() {
        int left = 1,right = 1;
        int ret = 0;

        while(left <= right) {
            ret++;
            // 用来统计最大可以跳到的位置
            int r = right;
            for(int i = left;i <= right;i++) {
                // 遍历整个可以跳到的区间，进行统计最大值
                r = Math.max(r,arr[i] + i);
                if(r >= n) {
                    return ret;
                }
            }
            // 更新left 和 right
            left = right + 1;
            right = r;
        }

        return -1;
    }
    // bfs的写法一：
    public static int bfs() {
        Queue<Integer> queue = new LinkedList<>();
        queue.add(1); // 存储下标
        int ret = 0;
        while(!queue.isEmpty()) {
            ret++;
            int size = queue.size();
            for(int k = 0;k < size;k++) {
                int maxStep = -INF;
                int maxIndex = -INF;
                int index = queue.poll();
                int step = 0;
                for(int i = index + 1;i <= index + arr[index];i++) {
                    if(i >= n) {
                        return ret;
                    }
                    if(arr[i] > 0) {
                        // 往前走，看最大值
                        step = arr[i] + i;
                    }
                    if(step > maxStep) {
                        // 更新
                        maxStep = step;
                        maxIndex = i;
                    }
                }
                if(maxIndex != -INF) {
                    queue.add(maxIndex);
                }
            }
        }
        return -1;
    }




    /**
     * 宵暗的妖怪
     * https://ac.nowcoder.com/acm/problem/213484
     */
    // 方法二：
    // 打家劫舍问题
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int[] arr = new int[n + 1];
        for(int i = 1;i <= n;i++) {
            arr[i] = in.nextInt();
        }

        long[] f = new long[n + 1]; // 表示：在i位置为中间部分进行吞噬后，以这个位置为结尾的最大饱食值
        long[] g = new long[n + 1]; // 表示：在i位置为中间部分不进行吞噬，以这个位置为结尾的最大饱食值
        // 在前3个中，必吃 2 下标这个位置
        f[2] = arr[2];// 初始化

        for(int i = 3;i <= n;i++) {
            // 最后一个位置不能进行吞噬
            if(i != n) {
                // i这个位置被吃的话，那么i-1位置和i+1位置是不能再选择的了
                f[i] = arr[i] + g[i - 2];
            }
            // i位置不吃的话，那么在其前一个位置进行选择吃或者不吃的最大值
            g[i] = Math.max(f[i - 1],g[i - 1]);
        }
        // 以后一个位置不进行吞噬，那么最高是以i-1作为中间值进行吞噬的
        System.out.println(Math.max(f[n - 1],g[n - 1]));
    }

    // 方法一：
    // 单线性dp
    public static void main1(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int[] arr = new int[n + 1];
        for(int i = 1;i <= n;i++) {
            arr[i] = in.nextInt();
        }
        // dp[i]：从1~i位置进行吞噬，最大的饱食值
        long[] dp = new long[n + 1];

        for(int i = 3;i <= n;i++) {
            // 每次是以某个位置为结尾进行过吞噬，之后这个位置吞噬后，在前面进行过寻找前面的最大吞噬值
            // 如过是选arr[i - 1]这个中间元素的话，就是在前面去找区间的最大饱食值
            // 如果不是选arr[i - 1]这个中间元素的话，就在i的前面去继承最大的饱食值
            dp[i] = Math.max(dp[i - 3] + arr[i - 1],dp[i - 1]);
        }

        System.out.println(dp[n]);
    }




    /**
     * MT2 棋子翻转
     * https://www.nowcoder.com/practice/a8c89dc768c84ec29cbf9ca065e3f6b4?tpId=128&tqId=33769&ru=/exam/oj
     */
    int[] dx = {0,0,-1,1};
    int[] dy = {1,-1,0,0};

    public int[][] flipChess (int[][] A, int[][] f) {
        for(int[] arr : f) {
            int a = arr[0] - 1;
            int b = arr[1] - 1;
            for(int k = 0;k < 4;k++) {
                int x = a + dx[k];
                int y = b + dy[k];
                if(x >= 0 && x < 4 && y >= 0 &&y < 4) {
                    if(A[x][y] == 0) {
                        A[x][y] = 1;
                    }else {
                        A[x][y] = 0;
                    }
                }
            }
        }
        return A;
    }
}
